package bszt.redbook;

import java.util.Arrays;
import java.util.Scanner;

public class Code02 {

    /**
     * 问题描述
     * K小姐最近在整理她的书架，她希望将书架上的书分为两类，并且将它们排成一排。为了让书架看起来更美观，她希望相邻的书尽量属于同一类别。每当相邻的两本书属于不同的类别时，K小姐就会觉得不美观
     * 书架上的一些书已经固定不能移动，而其他书可以自由移动。K小姐想知道，如何移动这些可以移动的书籍，使得不美观程度最小
     * <p></p>
     * 输入格式
     * 第一行输入一个整数n，表示书的数量。
     * 第二行输入n个整数a_i，表示书的类别。其中a_i=1表示书是第一类，a_i=2表示书是第二类
     * 第三行输入n个整数b_i，表示书是否可以移动。其中b_i=1表示第i本书可以移动，b_i=0表示第i本书不可以移动
     * <p></p>
     * 输出格式
     * 输出一个正整数，表示不美观程度的最小值
     */

    static final int N = 101; // 最大书籍数量
    static int[][][] dp = new int[N][N][2]; // dp数组，表示当前书的索引、剩余可移动的第一类书数量和当前书的类别

    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);

        int n = sc.nextInt();
        int[] a = new int[n];
        int[] b = new int[n];

        // 初始化dp数组为-1
        for (int i = 0; i < N; i++) {
            for (int j = 0; j < N; j++) {
                Arrays.fill(dp[i][j], -1);
            }
        }

        // 读取书的类别并转换为0-indexed
        for (int i = 0; i < n; i++) {
            a[i] = sc.nextInt() - 1; // 转换为0-indexed
        }

        int t = 0; // 可移动的第一类书的数量
        for (int i = 0; i < n; i++) {
            b[i] = sc.nextInt(); // 读取书是否可移动
            if (b[i] == 1 && a[i] != 0) { // 如果书可以移动且类别不为0
                t++; // 统计可移动的第一类书的数量
            }
        }

        // 调用DFS函数，计算最小不美观程度
        System.out.println(dfs(0, t, 0, a, b, n));
    }

    // 定义DFS函数进行状态转移
    static int dfs(int u, int l, int k, int[] a, int[] b, int n) {
        // 处理完所有书时，如果没有剩余的可移动书，返回不美观程度为0; 否则返回一个很大的值
        if (u == n) {
            return l == 0 ? 0 : 2 * n + 1;
        }

        // 如果当前状态已经计算过，直接返回结果
        if (dp[u][l][k] != -1) return dp[u][l][k];

        int v = (u > 0) ? 1 : 0; // 计算前一本书是否存在
        int res = 2 * n + 1; // 初始化最小不美观程度为一个很大的值

        // 如果当前书可以移动
        if (b[u] == 1) {
            // 尝试将当前书放置为第一类
            res = dfs(u + 1, l, 0, a, b, n) + (k ^ 0) * v;
            // 如果还有剩余的第一类可移动书，尝试将当前书放置为第二类
            if (l > 0) {
                res = Math.min(res, dfs(u + 1, l - 1, 1, a, b, n) + (k ^ 1) * v);
            }
        } else {
            // 如果当前书不可移动，保持原有类别
            res = Math.min(res, dfs(u + 1, l, a[u], a, b, n) + (k ^ a[u]) * v);
        }

        // 记录当前状态的最小不美观程度
        dp[u][l][k] = res;
        return res;
    }
}
